1. Field of the Invention
This invention relates to improvements in mainframe processing and, more particularly, to operational efficiencies that may be obtained by off-loading network transactions, including message queuing facilities (MQF), to an intelligent I/O device.
2. Discussion of Related Art
In the last several years, message oriented middleware products have been playing an essential role in integrating heterogeneous computing environments. In short, message oriented middleware systems facilitate the exchange of information between computing systems with different processing characteristic, such as different operating systems, processing architectures, data storage formats, file subsystems, communication stacks, and the like. Of particular relevance to the instant context are the family of products known as "message queuing facilities" (MQF). Many such systems are commercially available including the MQSeries from IBM, DEC Message Queue from Digital Equipment Corp., Momentum from XIPC, and Falcon from Microsoft Corp.
Message queuing facilities help applications in one computing system communicate with applications in another computing system by using queues to insulate or abstract each other's differences. With these systems, an application places or Puts a message on a queue, and the queue transmits its contents to another application's queue over a communications network. The other application removes or Gets the information from its queue and processes it.
More specifically, the sending application "connects" to a queue manager (a component of the MQF) and "opens" the local queue using the queue manager's queue definition. (Both the "connect" and "open" are executable "verbs" in MQseries application programming interface (API).) The application can then "put" the message on the queue.
Before sending a message, a MQF typically commits the message to persistent storage, typically to a direct access storage device (DASD). Once the message is committed to persistent storage, the MQF sends the message, via the communications stack, to the recipient's complementary and remote MQF. The remote MQF commits the message to persistent storage and sends an acknowledgment to the sending MQF. The acknowledgment back to the sending queue manager permits it to delete the message from the sender's persistent storage. The message stays on the remote MQF's persistent storage until the receiving application indicates it has completed its processing of it. The queue definition indicates whether the remote MQF must trigger the receiving application or if the receiver will poll the queue on its own. The use of persistent storage facilitates recoverability. This is known as a "persistent queue".)
Eventually, the receiving application is informed of the message in its local queue (i.e., the remote queue with respect to the sending application), and it like the sending application "connects" to its local queue manager and "opens" the queue the message is now on. The receiving application can then execute the "get" or "browse" verbs to either read the message from the queue or just look at it.
When either application is done processing its queue, it is free to issue the "close" verb and "disconnect" from the queue manager.
The persistent queue storage used by the MQF is logically an indexed sequential data set file. The messages are typically placed in the queue on a first in first out (FIFO) basis, but the queue model also allows indexed access for browsing and the direct access of the messages in the queue. The MQF executes file macros against the data set that contains the persistent message queue. For example, in the MVS/OS390 environment, an application executes a macro to open a named data set. The operating system initializes a set of control blocks that are used to map application requests for logical records into specific physical locations on a specific disk module. The physical location is identified with an MCHR address. (MCHR format is known).
In storing the message to the persistent storage, the mainframe-resident MQF communicates with the persistent storage device. Specifically, the MQF causes the operating system software to create and initiate a series of channel command words (CCWs), which contain information to identify the desired data and the desired action, e.g., read data. The series of CCWs is a "channel program." The CCWs contain the MCHR location of the record on the disk, the length of data to be read or written, and the mainframe memory address of where a record is to be read from or written to. The CCW format and the corresponding channel interface are known.)
Typical mainframe systems use DASD as the persistent storage device. The DASD has a DASD-specific arrangement of non-volatile storage devices, used to store the data, and a DASD storage control unit (DSTC). The DSTC executes various algorithms for retrieving data from CCW-specified locations, writing data to these locations, and the like. Physically, the DSTC includes a processor and ram. The ram is used to both hold control programs and to be used as cache. The defacto standard for DSTC functionality is the 3390 interface.
DSTCs implement a "lock facility" which is typically used to facilitate the sharing of DASD in a looselycoupled computing cluster. The lock facility helps manage the serialization and coordination of shared DASD as multiple computers in the cluster attempt to concurrently access it. The granularity of locks varies across implementations, but is typically at a record, data set, or DASD volume level. Physically, the DSTC has multiple electrical interfaces permitting multiple computers to attach to it.
Though MQF is helpful for many application, current MQF and related software utilize considerable mainframe resources. Given that the relevant systems are highly expensive (for example, to maintain transaction response time requirements), the computing resources expended on MQF and related software may translate into considerable sums.
Moreover, modern MQF have limited, if any, functionality allowing shared queues to be supported.
Also, mainframes are difficult to integrate into Open Systems.